home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / demo / pwrtcp11.exe / TNTCPP.CP_ / TNTCPP.bin
Text File  |  1994-11-14  |  35KB  |  1,202 lines
  1. //---------------------------------------------------------------------------
  2. //
  3. //  Module: tty.c
  4. //
  5. //  Purpose:
  6. //     The sample application demonstrates the usage of the COMM
  7. //     API.  It implements the new COMM API of Windows 3.1.
  8. //
  9. //     NOTE:  no escape sequences are translated, only
  10. //            the necessary control codes (LF, CR, BS, etc.)
  11. //
  12. //  Description of functions:
  13. //     Descriptions are contained in the function headers.
  14. //
  15. //---------------------------------------------------------------------------
  16. //
  17. //  Written by Microsoft Product Support Services, Windows Developer Support.
  18. //  Copyright (c) 1991 Microsoft Corporation.  All Rights Reserved.
  19. //
  20. //---------------------------------------------------------------------------
  21.  
  22. //***************************************************************************
  23. //
  24. //  Module: tntcpp.cpp
  25. //
  26. //  Purpose:
  27. //     The sample application demonstrates the usage of the PowerTCP
  28. //     API.  It uses the new PowerTCP DLL interface. Compiled under Windows 3.1
  29. //     and Windows NT 3.5 Beta
  30. //
  31. //     NOTE: This code was derived from Microsoft's tty.h
  32. //             
  33. //***************************************************************************
  34. //
  35. //  Written by Dart Communication Application Programming Group.
  36. //  Copyright (c) 1994 Dart Communications.  All Rights Reserved.
  37. //
  38. //***************************************************************************
  39.  
  40. #define STRICT       // be bold!
  41. #pragma warning (disable:4100 4355 4699)
  42.  
  43. #include <windows.h>
  44. #include <commdlg.h>
  45. #include <string.h>
  46. #include <malloc.h>
  47.  
  48. #include "version.h"
  49. #include "tntc.hh"
  50. #include "..\..\include\powertcp.h"
  51. #include "..\..\include\powertcp.hpp" // for CPowerTcp class def
  52. #include "..\..\include\powertnt.hpp" // for CPowerTelnet class def
  53. #include "tntsampl.hpp" // for our Derived Class
  54. #include "tntsamp.h"
  55.  
  56. char           szHost[20]="" ;
  57. char              szPort[5]="23" ;          
  58. WORD            Port;
  59. BOOL            TransOk;
  60. HINSTANCE    hInstance=NULL;
  61. PTTYINFO TTYInfo=NULL;
  62.  
  63. CMyPowerTelnet *MyPowerTelnet=NULL;
  64.  
  65. //---------------------------------------------------------------------------
  66. //  int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
  67. //                      LPSTR lpszCmdLine, int nCmdShow )
  68. //
  69. //  Description:
  70. //     This is the main window loop!
  71. //
  72. //  Parameters:
  73. //     As documented for all WinMain() functions.
  74. //
  75. //---------------------------------------------------------------------------
  76.  
  77. int PASCAL WinMain( HINSTANCE hNewInstance, HINSTANCE hPrevInstance,
  78.                     LPSTR lpszCmdLine, int nCmdShow )
  79. {
  80.    HWND  hTTYWnd ;
  81.    MSG   msg ;
  82.  
  83.    hInstance=hNewInstance;
  84.  
  85.    if (!hPrevInstance)
  86.       if (!InitApplication( hInstance ))
  87.          return ( FALSE ) ;
  88.  
  89.    if (NULL == (hTTYWnd = InitInstance( hInstance, nCmdShow )))
  90.       return ( FALSE ) ;
  91.  
  92.    while (GetMessage( &msg, NULL, 0, 0 ))
  93.    {
  94.       if (!TranslateAccelerator( hTTYWnd, ghAccel, &msg ))
  95.       {
  96.          TranslateMessage( &msg ) ;
  97.          DispatchMessage( &msg ) ;
  98.       }
  99.    }
  100.    return ( (int) msg.wParam ) ;
  101.  
  102. } // end of WinMain()
  103.  
  104. //---------------------------------------------------------------------------
  105. //  BOOL InitApplication( HANDLE hInstance )
  106. //
  107. //  Description:
  108. //     First time initialization stuff.  This registers information
  109. //     such as window classes.
  110. //
  111. //  Parameters:
  112. //     HANDLE hInstance
  113. //        Handle to this instance of the application.
  114. //
  115. //---------------------------------------------------------------------------
  116.  
  117. BOOL InitApplication( HINSTANCE hInstance )
  118. {
  119.    WNDCLASS  wndclass ;
  120.  
  121.    // register tty window class
  122.  
  123.    wndclass.style =         0 ;
  124.    wndclass.lpfnWndProc =   TTYWndProc ;
  125.    wndclass.cbClsExtra =    0 ;
  126.    wndclass.cbWndExtra =    0;
  127.    wndclass.hInstance =     hInstance ;
  128.    wndclass.hIcon =         LoadIcon( hInstance, "PowerTNT" );
  129.    wndclass.hCursor =       LoadCursor( NULL, IDC_ARROW ) ;
  130.    wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  131.    wndclass.lpszMenuName =  MAKEINTRESOURCE( TTYMENU ) ;
  132.    wndclass.lpszClassName = gszTTYClass ;
  133.  
  134.    return( RegisterClass( &wndclass ) ) ;
  135.  
  136. } // end of InitApplication()
  137.  
  138. //---------------------------------------------------------------------------
  139. //  HWND InitInstance( HANDLE hInstance, int nCmdShow )
  140. //
  141. //  Description:
  142. //     Initializes instance specific information.
  143. //
  144. //  Parameters:
  145. //     HANDLE hInstance
  146. //        Handle to instance
  147. //
  148. //     int nCmdShow
  149. //        How do we show the window?
  150. //
  151. //---------------------------------------------------------------------------
  152.  
  153. HWND InitInstance( HINSTANCE hInstance, int nCmdShow )
  154. {
  155.    HWND  hTTYWnd ;
  156.  
  157.    // load accelerators
  158.    ghAccel = LoadAccelerators( hInstance, MAKEINTRESOURCE( TTYACCEL ) ) ;
  159.  
  160.    // create the TTY window
  161.    hTTYWnd = CreateWindow( gszTTYClass, gszAppName,
  162.                            WS_OVERLAPPEDWINDOW,
  163.                            CW_USEDEFAULT, CW_USEDEFAULT,
  164.                            CW_USEDEFAULT, CW_USEDEFAULT,
  165.                            NULL, NULL, hInstance, NULL ) ;
  166.  
  167.    if (NULL == hTTYWnd)
  168.       return ( NULL ) ;
  169.    
  170.    ShowWindow( hTTYWnd, nCmdShow ) ;
  171.    UpdateWindow( hTTYWnd ) ;
  172.    SetWindowText(hTTYWnd, " PowerTCP TELNET Demo ");
  173.    OpenConnection(hTTYWnd);
  174.  
  175.    return ( hTTYWnd ) ;
  176.  
  177. } // end of InitInstance()
  178.  
  179. //---------------------------------------------------------------------------
  180. //  LRESULT FAR PASCAL __export TTYWndProc( HWND hWnd, UINT uMsg,
  181. //                                 WPARAM wParam, LPARAM lParam )
  182. //
  183. //  Description:
  184. //     This is the TTY Window Proc.  This handles ALL messages
  185. //     to the tty window.
  186. //
  187. //  Parameters:
  188. //     As documented for Window procedures.
  189. //
  190. //---------------------------------------------------------------------------
  191.  
  192. LRESULT CALLBACK TTYWndProc( HWND hWnd, UINT uMsg,
  193.                                WPARAM wParam, LPARAM lParam )
  194. {
  195.    switch (uMsg)
  196.    {
  197.       case WM_CREATE:
  198.          return ( CreateTTYInfo( hWnd ) ) ;
  199.  
  200.       case WM_COMMAND:
  201.       {
  202.          switch ((WORD) wParam)
  203.          {
  204.             case IDM_CONNECT:
  205.                if (!OpenConnection( hWnd ))
  206.                   MessageBox( hWnd, "Connection failed.", gszAppName,
  207.                               MB_ICONEXCLAMATION ) ;
  208.                break ;
  209.  
  210.             case IDM_DISCONNECT:
  211.                CloseConnection( hWnd ) ;
  212.                int i;
  213.                i=5;
  214.                break ;
  215.  
  216.             case IDM_ABOUT:
  217.                GoModalDialogBoxParam ( hInstance,
  218.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  219.                                        hWnd,
  220.                                        AboutDlgProc, 0l ) ;
  221.                break;
  222.  
  223.             case IDM_EXIT:
  224.                PostMessage( hWnd, WM_CLOSE, 0, 0L ) ;
  225.                break ;
  226.          }
  227.       }
  228.       break ;
  229.  
  230.       case WM_PAINT:
  231.          PaintTTY( hWnd ) ;
  232.          break ;
  233.  
  234.       case WM_SIZE:
  235.          SizeTTY( hWnd, HIWORD( lParam ), LOWORD( lParam ) ) ;
  236.          break ;
  237.  
  238.       case WM_HSCROLL:
  239.          ScrollTTYHorz( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  240.          break ;
  241.  
  242.       case WM_VSCROLL:
  243.          ScrollTTYVert( hWnd, (WORD) wParam, LOWORD( lParam ) ) ;
  244.          break ;
  245.  
  246.       case WM_CHAR:
  247.          ProcessTTYCharacter( hWnd, LOBYTE( wParam ) ) ;
  248.          break ;
  249.  
  250.       case WM_SETFOCUS:
  251.          SetTTYFocus( hWnd ) ;
  252.          break ;
  253.  
  254.       case WM_KILLFOCUS:
  255.          KillTTYFocus( hWnd ) ;
  256.          break ;
  257.  
  258.       case WM_DESTROY:
  259.          DestroyTTYInfo( hWnd ) ;
  260.          PostQuitMessage( 0 ) ;
  261.          break ;
  262.  
  263.       case WM_CLOSE:
  264.          if (MyPowerTelnet)
  265.                  {
  266.                  delete MyPowerTelnet;
  267.                 MyPowerTelnet=NULL;
  268.                 }
  269.          GoModalDialogBoxParam ( hInstance,
  270.                                        MAKEINTRESOURCE( ABOUTDLGBOX ),
  271.                                        hWnd,
  272.                                        AboutDlgProc, 0l ) ;
  273.          // fall through
  274.  
  275.       default:
  276.          return( DefWindowProc( hWnd, uMsg, wParam, lParam ) ) ;
  277.    }
  278.    return 0L ;
  279.  
  280. } // end of TTYWndProc()
  281.  
  282. //---------------------------------------------------------------------------
  283. //  LRESULT CreateTTYInfo( HWND hWnd )
  284. //
  285. //  Description:
  286. //     Creates the tty information structure and sets
  287. //     menu option availability.  Returns -1 if unsuccessful.
  288. //
  289. //  Parameters:
  290. //     HWND  hWnd
  291. //        Handle to main window.
  292. //
  293. //---------------------------------------------------------------------------
  294.  
  295. LRESULT CreateTTYInfo( HWND hWnd )
  296. {
  297.    HMENU       hMenu ;
  298.  
  299.    if (NULL == (TTYInfo =
  300.                    (PTTYINFO) malloc( sizeof( TTYINFO ) )))
  301.       return ( (LRESULT) -1 ) ;
  302.  
  303.    // initialize TTY info structure
  304.    memset (TTYInfo,0,sizeof(TTYINFO));
  305.  
  306.    COMDEV( TTYInfo )        = 0 ;
  307.    CONNECTED( TTYInfo )     = FALSE ;
  308.    CURSORSTATE( TTYInfo )   = CS_HIDE ;
  309.    LOCALECHO( TTYInfo )     = FALSE ;
  310.    AUTOWRAP( TTYInfo )      = TRUE ;
  311.  
  312.    // clear screen space
  313.    memset( SCREEN( TTYInfo ), ' ', MAXROWS * MAXCOLS ) ;
  314.  
  315.    // setup default font information
  316.  
  317.    LFTTYFONT( TTYInfo ).lfHeight =         12 ;
  318.    LFTTYFONT( TTYInfo ).lfWidth =          0 ;
  319.    LFTTYFONT( TTYInfo ).lfEscapement =     0 ;
  320.    LFTTYFONT( TTYInfo ).lfOrientation =    0 ;
  321.    LFTTYFONT( TTYInfo ).lfWeight =         0 ;
  322.    LFTTYFONT( TTYInfo ).lfItalic =         0 ;
  323.    LFTTYFONT( TTYInfo ).lfUnderline =      0 ;
  324.    LFTTYFONT( TTYInfo ).lfStrikeOut =      0 ;
  325.    LFTTYFONT( TTYInfo ).lfCharSet =        OEM_CHARSET ;
  326.    LFTTYFONT( TTYInfo ).lfOutPrecision =   OUT_DEFAULT_PRECIS ;
  327.    LFTTYFONT( TTYInfo ).lfClipPrecision =  CLIP_DEFAULT_PRECIS ;
  328.    LFTTYFONT( TTYInfo ).lfQuality =        DEFAULT_QUALITY ;
  329.    LFTTYFONT( TTYInfo ).lfPitchAndFamily = FIXED_PITCH | FF_MODERN ;
  330.    LFTTYFONT( TTYInfo ).lfFaceName[0] =    0 ;
  331.  
  332.    // reset the character information, etc.
  333.  
  334.    ResetTTYScreen( hWnd ) ;
  335.  
  336.    hMenu = GetMenu( hWnd ) ;
  337.    EnableMenuItem( hMenu, IDM_DISCONNECT,
  338.                    MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;
  339.    EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  340.  
  341.    return ( (LRESULT) TRUE ) ;
  342.  
  343. } // end of CreateTTYInfo()
  344.  
  345. //---------------------------------------------------------------------------
  346. //  BOOL DestroyTTYInfo( HWND hWnd )
  347. //
  348. //  Description:
  349. //     Destroys block associated with TTY window handle.
  350. //
  351. //  Parameters:
  352. //     HWND hWnd
  353. //        handle to TTY window
  354. //
  355. //---------------------------------------------------------------------------
  356.  
  357. BOOL DestroyTTYInfo( HWND hWnd )
  358. {
  359.  
  360.    if (!TTYInfo)
  361.       return ( FALSE ) ;
  362.  
  363.    // force connection closed (if not already closed)
  364.  
  365.    if (CONNECTED( TTYInfo ))
  366.       CloseConnection( hWnd ) ;
  367.  
  368.    DeleteObject( HTTYFONT( TTYInfo ) ) ;
  369.  
  370.    free ( TTYInfo ) ;
  371.    return ( TRUE ) ;
  372.  
  373. } // end of DestroyTTYInfo()
  374.  
  375. //---------------------------------------------------------------------------
  376. //  BOOL ResetTTYScreen( HWND hWnd, TTYINFO TTYInfo )
  377. //
  378. //  Description:
  379. //     Resets the TTY character information and causes the
  380. //     screen to resize to update the scroll information.
  381. //
  382. //  Parameters:
  383. //     TTYINFO  TTYInfo
  384. //        pointer to TTY info structure
  385. //
  386. //---------------------------------------------------------------------------
  387.  
  388. BOOL ResetTTYScreen( HWND hWnd)
  389. {
  390.    HDC         hDC ;
  391.    TEXTMETRIC  tm ;
  392.    RECT        rcWindow ;
  393.  
  394.    if (NULL == TTYInfo)
  395.       return ( FALSE ) ;
  396.  
  397.    if (NULL != HTTYFONT( TTYInfo ))
  398.       DeleteObject( HTTYFONT( TTYInfo ) ) ;
  399.  
  400.    HTTYFONT( TTYInfo ) = CreateFontIndirect( &LFTTYFONT( TTYInfo ) ) ;
  401.  
  402.    hDC = GetDC( hWnd ) ;
  403.    SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  404.    GetTextMetrics( hDC, &tm ) ;
  405.    ReleaseDC( hWnd, hDC ) ;
  406.  
  407.    XCHAR( TTYInfo ) = tm.tmAveCharWidth  ;
  408.    YCHAR( TTYInfo ) = tm.tmHeight + tm.tmExternalLeading ;
  409.  
  410.    // a slimy hack to force the scroll position, region to
  411.    // be recalculated based on the new character sizes
  412.  
  413.    GetWindowRect( hWnd, &rcWindow ) ;
  414.    SendMessage( hWnd, WM_SIZE, SIZENORMAL,
  415.                 (LPARAM) MAKELONG( rcWindow.right - rcWindow.left,
  416.                                    rcWindow.bottom - rcWindow.top ) ) ;
  417.  
  418.    return ( TRUE ) ;
  419.  
  420. } // end of ResetTTYScreen()
  421.  
  422. //---------------------------------------------------------------------------
  423. //  BOOL PaintTTY( HWND hWnd )
  424. //
  425. //  Description:
  426. //     Paints the rectangle determined by the paint struct of
  427. //     the DC.
  428. //
  429. //  Parameters:
  430. //     HWND hWnd
  431. //        handle to TTY window (as always)
  432. //
  433. //---------------------------------------------------------------------------
  434.  
  435. BOOL PaintTTY( HWND hWnd )
  436. {
  437.    int          nRow, nCol, nEndRow, nEndCol, nCount, nHorzPos, nVertPos ;
  438.    HDC          hDC ;
  439.    HGDIOBJ      hOldFont ;
  440.    PAINTSTRUCT  ps ;
  441.    RECT         rect ;
  442.  
  443.    if (NULL == TTYInfo)
  444.       return ( FALSE ) ;
  445.  
  446.    hDC = BeginPaint( hWnd, &ps ) ;
  447.    hOldFont = SelectObject( hDC, HTTYFONT( TTYInfo ) ) ;
  448.    SetTextColor( hDC, FGCOLOR( TTYInfo ) ) ;
  449.    SetBkColor( hDC, GetSysColor( COLOR_WINDOW ) ) ;
  450.    rect = ps.rcPaint ;
  451.    nRow =
  452.       min( MAXROWS - 1,
  453.            max( 0, (rect.top + YOFFSET( TTYInfo )) / YCHAR( TTYInfo ) ) ) ;
  454.    nEndRow =
  455.       min( MAXROWS - 1,
  456.            ((rect.bottom + YOFFSET( TTYInfo ) - 1) / YCHAR( TTYInfo ) ) ) ;
  457.    nCol =
  458.       min( MAXCOLS - 1,
  459.            max( 0, (rect.left + XOFFSET( TTYInfo )) / XCHAR( TTYInfo ) ) ) ;
  460.    nEndCol =
  461.       min( MAXCOLS - 1,
  462.            ((rect.right + XOFFSET( TTYInfo ) - 1) / XCHAR( TTYInfo ) ) ) ;
  463.    nCount = nEndCol - nCol + 1 ;
  464.    for (; nRow <= nEndRow; nRow++)
  465.    {
  466.       nVertPos = (nRow * YCHAR( TTYInfo )) - YOFFSET( TTYInfo ) ;
  467.       nHorzPos = (nCol * XCHAR( TTYInfo )) - XOFFSET( TTYInfo ) ;
  468.       rect.top = nVertPos ;
  469.       rect.bottom = nVertPos + YCHAR( TTYInfo ) ;
  470.       rect.left = nHorzPos ;
  471.       rect.right = nHorzPos + XCHAR( TTYInfo ) * nCount ;
  472.       SetBkMode( hDC, OPAQUE ) ;
  473.       ExtTextOut( hDC, nHorzPos, nVertPos, ETO_OPAQUE | ETO_CLIPPED, &rect,
  474.                   (LPSTR)( SCREEN( TTYInfo ) + nRow * MAXCOLS + nCol ),
  475.                   nCount, NULL ) ;
  476.    }
  477.    SelectObject( hDC, hOldFont ) ;
  478.    EndPaint( hWnd, &ps ) ;
  479.    MoveTTYCursor( hWnd ) ;
  480.    return ( TRUE ) ;
  481.  
  482. } // end of PaintTTY()
  483.  
  484. //---------------------------------------------------------------------------
  485. //  BOOL SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  486. //
  487. //  Description:
  488. //     Sizes TTY and sets up scrolling regions.
  489. //
  490. //  Parameters:
  491. //     HWND hWnd
  492. //        handle to TTY window
  493. //
  494. //     WORD wVertSize
  495. //        new vertical size
  496. //
  497. //     WORD wHorzSize
  498. //        new horizontal size
  499. //
  500. //---------------------------------------------------------------------------
  501.  
  502. BOOL SizeTTY( HWND hWnd, WORD wVertSize, WORD wHorzSize )
  503. {
  504.    int        nScrollAmt ;
  505.  
  506.    if (NULL == TTYInfo)
  507.       return ( FALSE ) ;
  508.  
  509.    YSIZE( TTYInfo ) = (int) wVertSize ;
  510.    YSCROLL( TTYInfo ) = max( 0, (MAXROWS * YCHAR( TTYInfo )) -
  511.                                YSIZE( TTYInfo ) ) ;
  512.    nScrollAmt = min( YSCROLL( TTYInfo ), YOFFSET( TTYInfo ) ) -
  513.                      YOFFSET( TTYInfo ) ;
  514.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  515.  
  516.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  517.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), FALSE ) ;
  518.    SetScrollRange( hWnd, SB_VERT, 0, YSCROLL( TTYInfo ), TRUE ) ;
  519.  
  520.    XSIZE( TTYInfo ) = (int) wHorzSize ;
  521.    XSCROLL( TTYInfo ) = max( 0, (MAXCOLS * XCHAR( TTYInfo )) -
  522.                                 XSIZE( TTYInfo ) ) ;
  523.    nScrollAmt = min( XSCROLL( TTYInfo ), XOFFSET( TTYInfo )) -
  524.                      XOFFSET( TTYInfo ) ;
  525.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  526.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  527.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), FALSE ) ;
  528.    SetScrollRange( hWnd, SB_HORZ, 0, XSCROLL( TTYInfo ), TRUE ) ;
  529.  
  530.    InvalidateRect( hWnd, NULL, TRUE ) ;
  531.  
  532.    return ( TRUE ) ;
  533.  
  534. } // end of SizeTTY()
  535.  
  536. //---------------------------------------------------------------------------
  537. //  BOOL ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  538. //
  539. //  Description:
  540. //     Scrolls TTY window vertically.
  541. //
  542. //  Parameters:
  543. //     HWND hWnd
  544. //        handle to TTY window
  545. //
  546. //     WORD wScrollCmd
  547. //        type of scrolling we're doing
  548. //
  549. //     WORD wScrollPos
  550. //        scroll position
  551. //
  552. //---------------------------------------------------------------------------
  553.  
  554. BOOL ScrollTTYVert( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  555. {
  556.    int        nScrollAmt ;
  557.  
  558.    if (NULL == TTYInfo)
  559.       return ( FALSE ) ;
  560.  
  561.    switch (wScrollCmd)
  562.    {
  563.       case SB_TOP:
  564.          nScrollAmt = -YOFFSET( TTYInfo ) ;
  565.          break ;
  566.  
  567.       case SB_BOTTOM:
  568.          nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  569.          break ;
  570.  
  571.       case SB_PAGEUP:
  572.          nScrollAmt = -YSIZE( TTYInfo ) ;
  573.          break ;
  574.  
  575.       case SB_PAGEDOWN:
  576.          nScrollAmt = YSIZE( TTYInfo ) ;
  577.          break ;
  578.  
  579.       case SB_LINEUP:
  580.          nScrollAmt = -YCHAR( TTYInfo ) ;
  581.          break ;
  582.  
  583.       case SB_LINEDOWN:
  584.          nScrollAmt = YCHAR( TTYInfo ) ;
  585.          break ;
  586.  
  587.       case SB_THUMBPOSITION:
  588.          nScrollAmt = wScrollPos - YOFFSET( TTYInfo ) ;
  589.          break ;
  590.  
  591.       default:
  592.          return ( FALSE ) ;
  593.    }
  594.    if ((YOFFSET( TTYInfo ) + nScrollAmt) > YSCROLL( TTYInfo ))
  595.       nScrollAmt = YSCROLL( TTYInfo ) - YOFFSET( TTYInfo ) ;
  596.    if ((YOFFSET( TTYInfo ) + nScrollAmt) < 0)
  597.       nScrollAmt = -YOFFSET( TTYInfo ) ;
  598.    ScrollWindow( hWnd, 0, -nScrollAmt, NULL, NULL ) ;
  599.    YOFFSET( TTYInfo ) = YOFFSET( TTYInfo ) + nScrollAmt ;
  600.    SetScrollPos( hWnd, SB_VERT, YOFFSET( TTYInfo ), TRUE ) ;
  601.  
  602.    return ( TRUE ) ;
  603.  
  604. } // end of ScrollTTYVert()
  605.  
  606. //---------------------------------------------------------------------------
  607. //  BOOL ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  608. //
  609. //  Description:
  610. //     Scrolls TTY window horizontally.
  611. //
  612. //  Parameters:
  613. //     HWND hWnd
  614. //        handle to TTY window
  615. //
  616. //     WORD wScrollCmd
  617. //        type of scrolling we're doing
  618. //
  619. //     WORD wScrollPos
  620. //        scroll position
  621. //
  622. //---------------------------------------------------------------------------
  623.  
  624. BOOL ScrollTTYHorz( HWND hWnd, WORD wScrollCmd, WORD wScrollPos )
  625. {
  626.    int        nScrollAmt ;
  627.  
  628.    if (NULL == TTYInfo)
  629.       return ( FALSE ) ;
  630.  
  631.    switch (wScrollCmd)
  632.    {
  633.       case SB_TOP:
  634.          nScrollAmt = -XOFFSET( TTYInfo ) ;
  635.          break ;
  636.  
  637.       case SB_BOTTOM:
  638.          nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  639.          break ;
  640.  
  641.       case SB_PAGEUP:
  642.          nScrollAmt = -XSIZE( TTYInfo ) ;
  643.          break ;
  644.  
  645.       case SB_PAGEDOWN:
  646.          nScrollAmt = XSIZE( TTYInfo ) ;
  647.          break ;
  648.  
  649.       case SB_LINEUP:
  650.          nScrollAmt = -XCHAR( TTYInfo ) ;
  651.          break ;
  652.  
  653.       case SB_LINEDOWN:
  654.          nScrollAmt = XCHAR( TTYInfo ) ;
  655.          break ;
  656.  
  657.       case SB_THUMBPOSITION:
  658.          nScrollAmt = wScrollPos - XOFFSET( TTYInfo ) ;
  659.          break ;
  660.  
  661.       default:
  662.          return ( FALSE ) ;
  663.    }
  664.    if ((XOFFSET( TTYInfo ) + nScrollAmt) > XSCROLL( TTYInfo ))
  665.       nScrollAmt = XSCROLL( TTYInfo ) - XOFFSET( TTYInfo ) ;
  666.    if ((XOFFSET( TTYInfo ) + nScrollAmt) < 0)
  667.       nScrollAmt = -XOFFSET( TTYInfo ) ;
  668.    ScrollWindow( hWnd, -nScrollAmt, 0, NULL, NULL ) ;
  669.    XOFFSET( TTYInfo ) = XOFFSET( TTYInfo ) + nScrollAmt ;
  670.    SetScrollPos( hWnd, SB_HORZ, XOFFSET( TTYInfo ), TRUE ) ;
  671.  
  672.    return ( TRUE ) ;
  673.  
  674. } // end of ScrollTTYHorz()
  675.  
  676. //---------------------------------------------------------------------------
  677. //  BOOL SetTTYFocus( HWND hWnd )
  678. //
  679. //  Description:
  680. //     Sets the focus to the TTY window also creates caret.
  681. //
  682. //  Parameters:
  683. //     HWND hWnd
  684. //        handle to TTY window
  685. //
  686. //---------------------------------------------------------------------------
  687.  
  688. BOOL SetTTYFocus( HWND hWnd )
  689. {
  690. if (NULL == TTYInfo)
  691.     return ( FALSE ) ;
  692.  
  693.  if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_SHOW))
  694.  {
  695.       CreateCaret( hWnd, NULL, XCHAR( TTYInfo ), YCHAR( TTYInfo ) ) ;
  696.       ShowCaret( hWnd ) ;
  697.       CURSORSTATE( TTYInfo ) = CS_SHOW ;
  698.  }
  699.    MoveTTYCursor( hWnd ) ;
  700.    return ( TRUE ) ;
  701.  
  702. } // end of SetTTYFocus()
  703.  
  704. //---------------------------------------------------------------------------
  705. //  BOOL KillTTYFocus( HWND hWnd )
  706. //
  707. //  Description:
  708. //     Kills TTY focus and destroys the caret.
  709. //
  710. //  Parameters:
  711. //     HWND hWnd
  712. //        handle to TTY window
  713. //
  714. //---------------------------------------------------------------------------
  715.  
  716. BOOL KillTTYFocus( HWND hWnd )
  717. {
  718.    if (NULL == TTYInfo)
  719.       return ( FALSE ) ;
  720.  
  721.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) != CS_HIDE))
  722.    {
  723.       HideCaret( hWnd ) ;
  724.       DestroyCaret() ;
  725.       CURSORSTATE( TTYInfo ) = CS_HIDE ;
  726.    }
  727.    return ( TRUE ) ;
  728.  
  729. } // end of KillTTYFocus()
  730.  
  731. //---------------------------------------------------------------------------
  732. //  BOOL MoveTTYCursor( HWND hWnd )
  733. //
  734. //  Description:
  735. //     Moves caret to current position.
  736. //
  737. //  Parameters:
  738. //     HWND hWnd
  739. //        handle to TTY window
  740. //
  741. //---------------------------------------------------------------------------
  742.  
  743. BOOL MoveTTYCursor( HWND hWnd )
  744. {
  745.    if (NULL == TTYInfo)
  746.       return ( FALSE ) ;
  747.  
  748.    if (CONNECTED( TTYInfo ) && (CURSORSTATE( TTYInfo ) & CS_SHOW))
  749.       SetCaretPos( (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  750.                    XOFFSET( TTYInfo ),
  751.                    (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  752.                    YOFFSET( TTYInfo ) ) ;
  753.  
  754.    return ( TRUE ) ;
  755.  
  756. } // end of MoveTTYCursor()
  757.  
  758.  
  759. //---------------------------------------------------------------------------
  760. //  BOOL ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  761. //
  762. //  Description:
  763. //     This simply writes a character to the port and echos it
  764. //     to the TTY screen if fLocalEcho is set.  Some minor
  765. //     keyboard mapping could be performed here.
  766. //
  767. //  Parameters:
  768. //     HWND hWnd
  769. //        handle to TTY window
  770. //
  771. //     BYTE bOut
  772. //        byte from keyboard
  773. //
  774. //---------------------------------------------------------------------------
  775.  
  776. BOOL ProcessTTYCharacter( HWND hWnd, BYTE bOut )
  777. {
  778.    if (NULL == TTYInfo)
  779.       return ( FALSE ) ;
  780.  
  781.    if (!CONNECTED( TTYInfo ))
  782.       return ( FALSE ) ;
  783.  
  784.    WriteCommByte( hWnd, bOut ) ;
  785.    if (LOCALECHO( TTYInfo ))
  786.       WriteTTYBlock( hWnd, &bOut, 1 ) ;
  787.  
  788.    return ( TRUE ) ;
  789.  
  790. } // end of ProcessTTYCharacter()
  791.  
  792.  
  793. //********************************************************************
  794. //
  795. //  CMyPowerTelnet Class Definition
  796. //
  797. //********************************************************************
  798.  
  799. CMyPowerTelnet::CMyPowerTelnet(HINSTANCE hInstance) : CPowerTelnet(hInstance)
  800.     {
  801.     }
  802.     
  803. CMyPowerTelnet::~CMyPowerTelnet()
  804.     {
  805.     }
  806.  
  807. void CMyPowerTelnet::ConnectEvent(
  808.     LPCSTR    RemoteDotAddr, /* remote host connected to in dot notation */
  809.     WORD      RemotePort,/* remote port connected to */
  810.     LPCSTR    LocalDotAddr, /* local host address in dot notation */
  811.     WORD      LocalPort, /* local port */
  812.     LPCSTR    LocalName  /* name of default local host */
  813.     )
  814. {
  815.     HMENU hMenu;
  816.     hMenu = GetMenu( hWnd ) ;
  817.     EnableMenuItem( hMenu, IDM_DISCONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  818.     EnableMenuItem( hMenu, IDM_CONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  819.     CONNECTED( TTYInfo ) = TRUE;
  820.     SetTTYFocus(hWnd);
  821. }
  822.     
  823. void CMyPowerTelnet::TelnetRecvEvent(
  824.     LPVOID    Data,  /* data from remote source */ 
  825.     size_t    Cnt        /* byte count for RecvData */
  826.     )
  827. {
  828.    if (!Data)       
  829.        {
  830.         HMENU hMenu;
  831.            KillTTYFocus( hWnd ) ;
  832.            CONNECTED( TTYInfo )     = FALSE ;
  833.         hMenu = GetMenu( hWnd ) ;
  834.         EnableMenuItem( hMenu, IDM_CONNECT, MF_ENABLED | MF_BYCOMMAND ) ;
  835.         EnableMenuItem( hMenu, IDM_DISCONNECT, MF_GRAYED | MF_DISABLED | MF_BYCOMMAND ) ;  
  836.         delete this;
  837.         MyPowerTelnet=NULL;
  838.         }
  839.     else
  840.         WriteTTYBlock( hWnd, (LPBYTE)Data, (int) Cnt );
  841. }    
  842.  
  843. void CMyPowerTelnet::TelnetCmdEvent(
  844.     BYTE      Cmd,       /* TELNET command (WILL, WONT, DO, DONT...) */ 
  845.     BYTE      Option,    /* TELNET option number */ 
  846.     LPBYTE    SubOption, /* pointer to sub-option string */ 
  847.     size_t    SubOptionCnt        /* byte count for SubOption */
  848.     )
  849. {
  850.    switch (Cmd)
  851.        {
  852.        case WILL_CMD:
  853.            if(( Option == 3) || ( Option == 1))
  854.                    SendCmd(DO_CMD,Option,NULL,0,0);
  855.            else
  856.                    SendCmd(DONT_CMD,Option,NULL,0,0);
  857.            break;
  858.        case WONT_CMD:
  859.            break;
  860.        case DO_CMD:
  861.                if (Option==TERMTYPE_OPTION)
  862.                    // negotiate term type
  863.                    SendCmd(WILL_CMD,Option,NULL,0,0);
  864.                else
  865.                    SendCmd(WONT_CMD,Option,NULL,0,0);
  866.            break;
  867.        case DONT_CMD:
  868.                SendCmd(WONT_CMD,Option,NULL,0,0);
  869.            break;
  870.        case SB_CMD:
  871.            if( SubOptionCnt && SubOption) 
  872.                    SendCmd(SB_CMD,Option,(LPBYTE)"\000network",8,0);
  873.            else
  874.                   SendCmd(WONT_CMD,Option,NULL,0,0);
  875.            break;
  876.        default:
  877.            break; 
  878.        }           
  879. }    
  880.  
  881. void CMyPowerTelnet::ExceptionEvent(
  882.     PT_EXCEPTION ErrorCode,  /* spontaneous error notification */
  883.     LPCSTR    ErrorDesc  /* description of error */
  884.     )          
  885. {
  886. }
  887.                        
  888. //---------------------------------------------------------------------------
  889. //  BOOL FAR PASCAL __export ConnectDlgProc( HWND hDlg, UINT uMsg,
  890. //                                WPARAM wParam, LPARAM lParam )
  891. //
  892. //  Description:
  893. //    Creates a connect box for the connection.
  894. //
  895. //  Parameters:
  896. //     Same as standard dialog procedures.
  897. //
  898. //---------------------------------------------------------------------------
  899. //////////////////////////////////////////////////////////////
  900.  
  901. BOOL CALLBACK ConnectDlgProc( HWND hDlg, UINT uMsg,
  902.                                 WPARAM wParam, LPARAM lParam )
  903. {  
  904.    switch (uMsg)
  905.    {
  906.     case WM_INITDIALOG:
  907.          SetDlgItemText( hDlg, IDC_HOST, szHost ) ;
  908.          SetDlgItemText( hDlg, IDC_PORT, szPort ) ;
  909.     break;
  910.       
  911.     case WM_COMMAND:
  912.       if ((WORD) wParam == IDD_OK)
  913.        {
  914.            GetDlgItemText( hDlg, IDC_HOST, szHost, sizeof( szHost ) ) ;
  915.            Port = (WORD)GetDlgItemInt( hDlg, IDC_PORT, &TransOk, FALSE); 
  916.         EndDialog( hDlg, TRUE ) ;
  917.         return ( TRUE ) ;
  918.        }
  919.        
  920.       if ((WORD) wParam == IDD_CANCEL)
  921.        {
  922.         EndDialog( hDlg, FALSE) ;
  923.         return (FALSE) ;
  924.        }
  925.        
  926.     break;
  927.    }
  928.  return ( FALSE ) ;
  929. } // end of ConnectDlgProc()
  930.  
  931.  
  932.  
  933. BOOL OpenConnection( HWND hWnd )
  934. {
  935.  
  936. HCURSOR    hOldCursor, hWaitCursor ;
  937.  
  938. // show the hourglass cursor
  939. hWaitCursor = LoadCursor( NULL, IDC_WAIT ) ;
  940. hOldCursor = SetCursor( hWaitCursor ) ;
  941.  
  942.  
  943. if (GoModalDialogBoxParam( hInstance, MAKEINTRESOURCE( CONNECTDLGBOX ), hWnd,
  944.                        ConnectDlgProc, 0l))
  945.    {
  946.    
  947.    MyPowerTelnet=new CMyPowerTelnet(hInstance);
  948.    MyPowerTelnet->hWnd=hWnd;
  949.  
  950.    MyPowerTelnet->Connect (
  951.         NULL,                 /* use license number assigned to you by Dart */ 
  952.         PT_SHOW,        /* set to PT_DEBUG to get debugging information */ 
  953.         (LPCSTR) szHost,  /* use name or dot notation */ 
  954.         Port,                     /* port to connect to (usually 23 for TELNET) */ 
  955.         NULL,                     /* NULL or local dot address for multi-homed host */
  956.         0                        /* use any local port available */ 
  957.         );
  958.     }
  959.     
  960. return (TRUE);
  961. } // end of OpenConnection()
  962.  
  963. //---------------------------------------------------------------------------
  964. //  BOOL CloseConnection( HWND hWnd )
  965. //
  966. //  Description:
  967. //     Closes the connection to the port.  Resets the connect flag
  968. //     in the TTYINFO struct.
  969. //
  970. //  Parameters:
  971. //     HWND hWnd
  972. //        handle to TTY window
  973. //
  974. //---------------------------------------------------------------------------
  975.  
  976. BOOL CloseConnection( HWND hWnd )
  977. {
  978.    if (MyPowerTelnet)
  979.         MyPowerTelnet->Close(TRUE);    // do a hard close
  980.    return ( TRUE ) ;
  981.  
  982. } // end of CloseConnection()
  983.  
  984.  
  985. //---------------------------------------------------------------------------
  986. //  BOOL WriteCommByte( HWND hWnd, BYTE bByte )
  987. //
  988. //  Description:
  989. //     Writes a byte to the COM port specified in the associated
  990. //     TTY info structure.
  991. //
  992. //  Parameters:
  993. //     HWND hWnd
  994. //        handle to TTY window
  995. //
  996. //     BYTE bByte
  997. //        byte to write to port
  998. //
  999. //---------------------------------------------------------------------------
  1000.  
  1001. BOOL WriteCommByte( HWND hWnd, BYTE bByte )
  1002. {
  1003.    if (NULL == TTYInfo)
  1004.       return ( FALSE ) ;
  1005.  
  1006.    //WriteComm( COMDEV( TTYInfo ), (LPSTR) &bByte, 1 ) ;
  1007.    if (MyPowerTelnet)
  1008.            MyPowerTelnet->Send(&bByte, 1, FALSE, 0);
  1009.  
  1010.    return ( TRUE ) ;
  1011.  
  1012. } // end of WriteCommByte()
  1013.  
  1014. //---------------------------------------------------------------------------
  1015. //  BOOL WriteTTYBlock( HWND hWnd, LPSTR lpBlock, int nLength )
  1016. //
  1017. //  Description:
  1018. //     Writes block to TTY screen.  Nothing fancy - just
  1019. //     straight TTY.
  1020. //
  1021. //  Parameters:
  1022. //     HWND hWnd
  1023. //        handle to TTY window
  1024. //
  1025. //     LPSTR lpBlock
  1026. //        far pointer to block of data
  1027. //
  1028. //     int nLength
  1029. //        length of block
  1030. //
  1031. //---------------------------------------------------------------------------
  1032.  
  1033. BOOL WriteTTYBlock( HWND hWnd, LPBYTE lpBlock, int nLength )
  1034. {
  1035.    int        i ;
  1036.    RECT       rect ;
  1037.  
  1038.    if (NULL == TTYInfo)
  1039.       return ( FALSE ) ;
  1040.  
  1041.    for (i = 0 ; i < nLength; i++)
  1042.    {
  1043.       switch (lpBlock[ i ])
  1044.       {
  1045.            case 0:
  1046.              // do not print NULLs
  1047.             break;
  1048.  
  1049.          case ASCII_BEL:
  1050.             // Bell
  1051.             MessageBeep( 0 ) ;
  1052.             break ;
  1053.  
  1054.          case ASCII_BS:
  1055.             // Backspace
  1056.             if (COLUMN( TTYInfo ) > 0)
  1057.                COLUMN( TTYInfo ) -- ;
  1058.             MoveTTYCursor( hWnd ) ;
  1059.             break ;
  1060.  
  1061.          case ASCII_CR:
  1062.             // Carriage return
  1063.             COLUMN( TTYInfo ) = 0 ;
  1064.             MoveTTYCursor( hWnd ) ;
  1065.             if (!NEWLINE( TTYInfo ))
  1066.                break;
  1067.  
  1068.             // fall through
  1069.  
  1070.          case ASCII_LF:
  1071.             // Line feed
  1072.             if (ROW( TTYInfo )++ == MAXROWS - 1)
  1073.             {
  1074.                memmove( (SCREEN( TTYInfo )),
  1075.                           (SCREEN( TTYInfo ) + MAXCOLS),
  1076.                           (MAXROWS - 1) * MAXCOLS ) ;
  1077.                memset( (SCREEN( TTYInfo ) + (MAXROWS - 1) * MAXCOLS),
  1078.                          ' ', MAXCOLS ) ;
  1079.                InvalidateRect( hWnd, NULL, FALSE ) ;
  1080.                ROW( TTYInfo )-- ;
  1081.             }
  1082.             MoveTTYCursor( hWnd ) ;
  1083.             break ;
  1084.  
  1085.          default:
  1086.             *(SCREEN( TTYInfo ) + ROW( TTYInfo ) * MAXCOLS +
  1087.                 COLUMN( TTYInfo )) = lpBlock[ i ] ;
  1088.             rect.left = (COLUMN( TTYInfo ) * XCHAR( TTYInfo )) -
  1089.                         XOFFSET( TTYInfo ) ;
  1090.             rect.right = rect.left + XCHAR( TTYInfo ) ;
  1091.             rect.top = (ROW( TTYInfo ) * YCHAR( TTYInfo )) -
  1092.                        YOFFSET( TTYInfo ) ;
  1093.             rect.bottom = rect.top + YCHAR( TTYInfo ) ;
  1094.             InvalidateRect( hWnd, &rect, FALSE ) ;
  1095.  
  1096.             // Line wrap
  1097.             if (COLUMN( TTYInfo ) < MAXCOLS - 1)
  1098.                COLUMN( TTYInfo )++ ;
  1099.             else if (AUTOWRAP( TTYInfo ))
  1100.                WriteTTYBlock( hWnd, (LPBYTE)"\r\n", 2 ) ;
  1101.             break;
  1102.       }
  1103.    }
  1104.    return ( TRUE ) ;
  1105.  
  1106. } // end of WriteTTYBlock()
  1107.  
  1108. //---------------------------------------------------------------------------
  1109. //  VOID GoModalDialogBoxParam( HINSTANCE hInstance,
  1110. //                                   LPCSTR lpszTemplate, HWND hWnd,
  1111. //                                   DLGPROC lpDlgProc, LPARAM lParam )
  1112. //
  1113. //  Description:
  1114. //     It is a simple utility function that simply performs the
  1115. //     MPI and invokes the dialog box with a DWORD paramter.
  1116. //
  1117. //  Parameters:
  1118. //     similar to that of DialogBoxParam() with the exception
  1119. //     that the lpDlgProc is not a procedure instance
  1120. //
  1121. //---------------------------------------------------------------------------
  1122.  
  1123. BOOL GoModalDialogBoxParam( HINSTANCE hInstance, LPCSTR lpszTemplate,
  1124.                              HWND hWnd, DLGPROC lpDlgProc, LPARAM lParam )
  1125. {   
  1126.     BOOL DlgResp  = DialogBoxParam( hInstance, lpszTemplate, hWnd, lpDlgProc, lParam ) ;
  1127.    return (DlgResp);
  1128. } // end of GoModalDialogBoxParam()
  1129.  
  1130. //---------------------------------------------------------------------------
  1131. //  BOOL FAR PASCAL __export AboutDlgProc( HWND hDlg, UINT uMsg,
  1132. //                                WPARAM wParam, LPARAM lParam )
  1133. //
  1134. //  Description:
  1135. //     Simulates the Windows System Dialog Box.
  1136. //
  1137. //  Parameters:
  1138. //     Same as standard dialog procedures.
  1139. //
  1140. //---------------------------------------------------------------------------
  1141.  
  1142. BOOL CALLBACK AboutDlgProc( HWND hDlg, UINT uMsg,
  1143.                               WPARAM wParam, LPARAM lParam )
  1144. {
  1145.    switch (uMsg)
  1146.    {
  1147.       case WM_INITDIALOG:
  1148.       {
  1149.          char         szBuffer[ MAXLEN_TEMPSTR ], szTemp[ MAXLEN_TEMPSTR ] ;
  1150.          DWORD        dwFreeMemory;
  1151.          WORD         wRevision, wVersion ;
  1152.  
  1153.          // sets up the version number for Windows
  1154.  
  1155.          wVersion = LOWORD( GetVersion() ) ;
  1156.          switch (HIBYTE( wVersion ))
  1157.          {
  1158.             case 10:
  1159.                wRevision = 1 ;
  1160.                break ;
  1161.  
  1162.             default:
  1163.                wRevision = 0 ;
  1164.                break;
  1165.          }
  1166.          wVersion &= 0xFF ;
  1167.  
  1168.          GetDlgItemText( hDlg, IDD_TITLELINE, szTemp, sizeof( szTemp ) ) ;
  1169.          wsprintf( szBuffer, szTemp, wVersion, wRevision ) ;
  1170.          SetDlgItemText( hDlg, IDD_TITLELINE, szBuffer ) ;
  1171.  
  1172.          // sets up version number for TTY
  1173.  
  1174.          GetDlgItemText( hDlg, IDD_VERSION, szTemp, sizeof( szTemp ) ) ;
  1175.          wsprintf( szBuffer, szTemp, VER_MAJOR, VER_MINOR, VER_BUILD ) ;
  1176.          SetDlgItemText( hDlg, IDD_VERSION, (LPSTR) szBuffer ) ;
  1177.  
  1178.          // get free memory information
  1179.  
  1180.          dwFreeMemory = GetFreeSpace( 0 ) / 1024L ;
  1181.          GetDlgItemText( hDlg, IDD_FREEMEM, szTemp, sizeof( szTemp ) ) ;
  1182.          wsprintf( szBuffer, szTemp, dwFreeMemory ) ;
  1183.          SetDlgItemText( hDlg, IDD_FREEMEM, (LPSTR) szBuffer ) ;
  1184.  
  1185.       }
  1186.       return ( TRUE ) ;
  1187.  
  1188.  
  1189.       case WM_COMMAND:
  1190.          if ((WORD) wParam == IDD_OK)
  1191.          {
  1192.             EndDialog( hDlg, TRUE ) ;
  1193.             return ( TRUE ) ;
  1194.          }
  1195.          break;
  1196.    }
  1197.    return ( FALSE ) ;
  1198.  
  1199. } // end of AboutDlgProc()
  1200.  
  1201.  
  1202.